home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / posixfile.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  8KB  |  234 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. """Extended file operations available in POSIX.
  5.  
  6. f = posixfile.open(filename, [mode, [bufsize]])
  7.       will create a new posixfile object
  8.  
  9. f = posixfile.fileopen(fileobject)
  10.       will create a posixfile object from a builtin file object
  11.  
  12. f.file()
  13.       will return the original builtin file object
  14.  
  15. f.dup()
  16.       will return a new file object based on a new filedescriptor
  17.  
  18. f.dup2(fd)
  19.       will return a new file object based on the given filedescriptor
  20.  
  21. f.flags(mode)
  22.       will turn on the associated flag (merge)
  23.       mode can contain the following characters:
  24.  
  25.   (character representing a flag)
  26.       a       append only flag
  27.       c       close on exec flag
  28.       n       no delay flag
  29.       s       synchronization flag
  30.   (modifiers)
  31.       !       turn flags 'off' instead of default 'on'
  32.       =       copy flags 'as is' instead of default 'merge'
  33.       ?       return a string in which the characters represent the flags
  34.               that are set
  35.  
  36.       note: - the '!' and '=' modifiers are mutually exclusive.
  37.             - the '?' modifier will return the status of the flags after they
  38.               have been changed by other characters in the mode string
  39.  
  40. f.lock(mode [, len [, start [, whence]]])
  41.       will (un)lock a region
  42.       mode can contain the following characters:
  43.  
  44.   (character representing type of lock)
  45.       u       unlock
  46.       r       read lock
  47.       w       write lock
  48.   (modifiers)
  49.       |       wait until the lock can be granted
  50.       ?       return the first lock conflicting with the requested lock
  51.               or 'None' if there is no conflict. The lock returned is in the
  52.               format (mode, len, start, whence, pid) where mode is a
  53.               character representing the type of lock ('r' or 'w')
  54.  
  55.       note: - the '?' modifier prevents a region from being locked; it is
  56.               query only
  57. """
  58.  
  59. class _posixfile_:
  60.     '''File wrapper class that provides extra POSIX file routines.'''
  61.     states = [
  62.         'open',
  63.         'closed']
  64.     
  65.     def __repr__(self):
  66.         file = self._file_
  67.         return "<%s posixfile '%s', mode '%s' at %s>" % (self.states[file.closed], file.name, file.mode, hex(id(self))[2:])
  68.  
  69.     
  70.     def open(self, name, mode = 'r', bufsize = -1):
  71.         import __builtin__ as __builtin__
  72.         return self.fileopen(__builtin__.open(name, mode, bufsize))
  73.  
  74.     
  75.     def fileopen(self, file):
  76.         import types as types
  77.         if repr(type(file)) != "<type 'file'>":
  78.             raise TypeError, 'posixfile.fileopen() arg must be file object'
  79.         
  80.         self._file_ = file
  81.         for maybemethod in dir(file):
  82.             if not maybemethod.startswith('_'):
  83.                 attr = getattr(file, maybemethod)
  84.                 if isinstance(attr, types.BuiltinMethodType):
  85.                     setattr(self, maybemethod, attr)
  86.                 
  87.             isinstance(attr, types.BuiltinMethodType)
  88.         
  89.         return self
  90.  
  91.     
  92.     def file(self):
  93.         return self._file_
  94.  
  95.     
  96.     def dup(self):
  97.         import posix as posix
  98.         if not hasattr(posix, 'fdopen'):
  99.             raise AttributeError, 'dup() method unavailable'
  100.         
  101.         return posix.fdopen(posix.dup(self._file_.fileno()), self._file_.mode)
  102.  
  103.     
  104.     def dup2(self, fd):
  105.         import posix
  106.         if not hasattr(posix, 'fdopen'):
  107.             raise AttributeError, 'dup() method unavailable'
  108.         
  109.         posix.dup2(self._file_.fileno(), fd)
  110.         return posix.fdopen(fd, self._file_.mode)
  111.  
  112.     
  113.     def flags(self, *which):
  114.         import fcntl as fcntl
  115.         import os as os
  116.         if which:
  117.             if len(which) > 1:
  118.                 raise TypeError, 'Too many arguments'
  119.             
  120.             which = which[0]
  121.         else:
  122.             which = '?'
  123.         l_flags = 0
  124.         if 'n' in which:
  125.             l_flags = l_flags | os.O_NDELAY
  126.         
  127.         if 'a' in which:
  128.             l_flags = l_flags | os.O_APPEND
  129.         
  130.         if 's' in which:
  131.             l_flags = l_flags | os.O_SYNC
  132.         
  133.         file = self._file_
  134.         if '=' not in which:
  135.             cur_fl = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0)
  136.             if '!' in which:
  137.                 l_flags = cur_fl & ~l_flags
  138.             else:
  139.                 l_flags = cur_fl | l_flags
  140.         
  141.         l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFL, l_flags)
  142.         if 'c' in which:
  143.             arg = '!' not in which
  144.             l_flags = fcntl.fcntl(file.fileno(), fcntl.F_SETFD, arg)
  145.         
  146.         if '?' in which:
  147.             which = ''
  148.             l_flags = fcntl.fcntl(file.fileno(), fcntl.F_GETFL, 0)
  149.             if os.O_APPEND & l_flags:
  150.                 which = which + 'a'
  151.             
  152.             if fcntl.fcntl(file.fileno(), fcntl.F_GETFD, 0) & 1:
  153.                 which = which + 'c'
  154.             
  155.             if os.O_NDELAY & l_flags:
  156.                 which = which + 'n'
  157.             
  158.             if os.O_SYNC & l_flags:
  159.                 which = which + 's'
  160.             
  161.             return which
  162.         
  163.  
  164.     
  165.     def lock(self, how, *args):
  166.         import struct as struct
  167.         import fcntl
  168.         if 'w' in how:
  169.             l_type = fcntl.F_WRLCK
  170.         elif 'r' in how:
  171.             l_type = fcntl.F_RDLCK
  172.         elif 'u' in how:
  173.             l_type = fcntl.F_UNLCK
  174.         else:
  175.             raise TypeError, 'no type of lock specified'
  176.         if '|' in how:
  177.             cmd = fcntl.F_SETLKW
  178.         elif '?' in how:
  179.             cmd = fcntl.F_GETLK
  180.         else:
  181.             cmd = fcntl.F_SETLK
  182.         l_whence = 0
  183.         l_start = 0
  184.         l_len = 0
  185.         if len(args) == 1:
  186.             l_len = args[0]
  187.         elif len(args) == 2:
  188.             (l_len, l_start) = args
  189.         elif len(args) == 3:
  190.             (l_len, l_start, l_whence) = args
  191.         elif len(args) > 3:
  192.             raise TypeError, 'too many arguments'
  193.         
  194.         import sys as sys
  195.         import os
  196.         if sys.platform in ('netbsd1', 'openbsd2', 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5', 'freebsd6', 'freebsd7', 'bsdos2', 'bsdos3', 'bsdos4'):
  197.             flock = struct.pack('lxxxxlxxxxlhh', l_start, l_len, os.getpid(), l_type, l_whence)
  198.         elif sys.platform in ('aix3', 'aix4'):
  199.             flock = struct.pack('hhlllii', l_type, l_whence, l_start, l_len, 0, 0, 0)
  200.         else:
  201.             flock = struct.pack('hhllhh', l_type, l_whence, l_start, l_len, 0, 0)
  202.         flock = fcntl.fcntl(self._file_.fileno(), cmd, flock)
  203.         if '?' in how:
  204.             if sys.platform in ('netbsd1', 'openbsd2', 'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5', 'bsdos2', 'bsdos3', 'bsdos4'):
  205.                 (l_start, l_len, l_pid, l_type, l_whence) = struct.unpack('lxxxxlxxxxlhh', flock)
  206.             elif sys.platform in ('aix3', 'aix4'):
  207.                 (l_type, l_whence, l_start, l_len, l_sysid, l_pid, l_vfs) = struct.unpack('hhlllii', flock)
  208.             elif sys.platform in ('linux2', 'linux2-alpha', 'linux2-hppa', 'linux2-mips', 'linux2-sparc'):
  209.                 (l_type, l_whence, l_start, l_len, l_pid, l_sysid) = struct.unpack('hhllhh', flock)
  210.             else:
  211.                 (l_type, l_whence, l_start, l_len, l_sysid, l_pid) = struct.unpack('hhllhh', flock)
  212.             if l_type != fcntl.F_UNLCK:
  213.                 if l_type == fcntl.F_RDLCK:
  214.                     return ('r', l_len, l_start, l_whence, l_pid)
  215.                 else:
  216.                     return ('w', l_len, l_start, l_whence, l_pid)
  217.             
  218.         
  219.  
  220.  
  221.  
  222. def open(name, mode = 'r', bufsize = -1):
  223.     '''Public routine to open a file as a posixfile object.'''
  224.     return _posixfile_().open(name, mode, bufsize)
  225.  
  226.  
  227. def fileopen(file):
  228.     '''Public routine to get a posixfile object from a Python file object.'''
  229.     return _posixfile_().fileopen(file)
  230.  
  231. SEEK_SET = 0
  232. SEEK_CUR = 1
  233. SEEK_END = 2
  234.